const moduleB = {
    // 开启命名空间：提高封装度和复用性
    namespaced: true,
    // 全局变量定义
    state: {
        count: 10,
        num: 1,
        todos: [
            { id: 1, text: 'B...', done: true },
            { id: 2, text: 'B...', done: true },
            { id: 3, text: 'B...', done: false }
        ]
    },
    // getters 相当于  store 的计算属性
    getters: {
        doneTodos: state => {
            console.log('moduleB getters b/doneTodos...');
            return state.todos.filter(todo => todo.done)
        },
        // Getter 也可以接受其他 getter 作为第二个参数
        doneTodosCount: (state, getters) => {
            console.log('moduleB getters b/doneTodosCount...');
            return getters.doneTodos.length
        },
        // 通过让 getter 返回一个函数，来实现给 getter 传参。getter 在通过方法访问时，每次都会去进行调用，而不会缓存结果
        getTodoById: (state) => (id) => {
            console.log('moduleB getters b/getTodoById...');
            return state.todos.find(todo => todo.id === id)
        }
    },
    // 同步事务：mutation 必须是同步函数，因为任何在回调函数中进行的状态的改变都是不可追踪的
    mutations: {
        increment(state) {
            console.log('moduleB mutations b/increment...');
            state.count++
        },
        // 携带参数
        incrementWithPayload(state, payload) {
            console.log('moduleB mutations b/incrementWithPayload...');
            state.count += payload.amount
        },
        reduce(state) {
            state.count--
            console.log('moduleB mutations b/reduce...');
        },
        reduceB(state) {
            state.count--
            console.log('moduleB mutations b/reduceB...');
        }
    },
    // 异步事务: actions 提交的是 mutation，而不是直接变更状态
    actions: {
        increment(context) {
            console.log('moduleB actions b/increment...');
            context.commit('increment')
        },
        // 在 action 内部执行异步操作,此处调用 mutations 内部的 increment 方法
        incrementAsync({ commit }, payload) {
            console.log('moduleB actions b/incrementAsync...');
            setTimeout(() => {
                commit('incrementWithPayload', payload)
            }, 1000)
        },
        // 包含返回值的异步
        actionA({ commit }) {
            console.log('moduleB actions b/actionA...');
            return new Promise((resolve, reject) => {
                setTimeout(() => {
                    commit('reduce')
                    resolve()
                }, 1000)
            })
        },
        // 多重异步嵌套
        actionB({ dispatch, commit }) {
            console.log('moduleB actions b/actionB...');
            return dispatch('actionA').then(() => {
                commit('reduceB')
            })
        }
    },

}
export default moduleB;